import {
  batchGetProductInfo,
  BatchGetProductInfoOptions,
  BatchGetProductInfoResult,
  cosDxmCallBack,
  DianxiaomiProductInfo,
  getSign,
  uploadFileToCos,
} from '@/api/product';
import { GigaProductDetialInfo } from './giga';
import { getAllFileHandleByDirectoryHandle, getFileName } from './utils';

export enum DxmState {
  draft = 'draft',
  offline = 'offline',
  online = 'online',
}

export enum ShipmentLimitSecond {
  '1个工作日内发货' = '86400',
  '2个工作日内发货' = '172800',
  '9个工作日内发货' = '777600',
}

export type MainProductSkuSpecReqs = MainProductSkuSpecReq[];

export interface MainProductSkuSpecReq {
  // 暂不清楚作用
  // 一般是 0
  parentSpecId: number;

  // 暂不清楚作用
  // 一般是 ""
  parentSpecName: string;

  // 暂不清楚作用
  // 一般是 0
  specId: number;

  // 暂不清楚作用
  // 一般是 ""
  specName: string;

  // 暂不清楚作用
  // 一般是轮播图的第二张图片
  previewImgUrls: string;

  // 相当于货号名称 skuIdInfo
  extCode: string;

  // 暂不清楚作用
  // 一般是 ""
  productSkcId: string;
}

export type ProductSkuSpecReqs = ProductSkuSpecReq;

export interface ProductSkuSpecReq {
  // 变种属性的 id
  // 一般是 "1001",对应颜色
  parentSpecId: string;

  // 变种属性的类型
  // 一般是 "颜色"
  parentSpecName: string;

  // 暂不清楚作用
  // 一般是 0
  specId: number;

  // 变种属性的值
  // 对应 giga 信息的 mainColor
  specName: string;
}

export type ProductSkuStockQuantityReqs = ProductSkuStockQuantityReq[];

export interface ProductSkuStockQuantityReq {
  // 仓库 id
  // 一般是 "WH-09092282531990900"
  // 可以通过 https://www.dianxiaomi.com/popTemuCategory/warehouseList.json 获取,但是一般固定
  warehouseId: string;

  // 仓库名称
  // 一般是 "上海仓"
  warehouseName: string;

  // 仓库库存
  // 对应 giga 信息的 available
  targetStockAvailable: number;
}

export type VariationList = Variation[];

export interface Variation {
  // 如果是新创建变种,那么 id 为 null
  id: string | null;

  // 暂不清楚作用
  // 一般是 0
  productSkuId: number;

  // 申报价格
  // 单位精确到美分
  // 对应 giga 信息的 totalPrice
  supplierPrice: number;

  // 相当于货号名称 skuIdInfo
  extCode: string;

  // 长度
  // 单位是 mm
  // 对应 giga 信息的 packageLength: string;
  // 注意单位的转换
  length: number;

  // 宽度
  // 单位是 mm
  // 对应 giga 信息的 packageWidth: string;
  // 注意单位的转换
  width: number;

  // 高度
  // 单位是 mm
  // 对应 giga 信息的 packageHeight: string;
  // 注意单位的转换
  height: number;

  // 重量
  // 单位是毫克
  // 对应 giga 信息的 packageWeight: string;
  // 注意单位的转换
  weight: number;

  // 暂不清楚作用
  // 一般是 "1"
  codeType: string;

  // 暂不清楚作用
  // 一般是 ""
  code: string;

  // 暂不清楚作用
  // 一般是 null
  sitePriceInfo: string | null;

  // 申报价格
  // 单位精确到美分
  // 对应 giga 信息的 supplierPrice 加一美元
  suggestedPrice: number;

  // 价格单位
  // 一般是 USD
  suggestedPriceCurrencyType: string;

  // 单品数量
  // 一般是 1
  numberOfPieces: number;

  // sku 分类类型
  // 一般是 1
  skuClassification: number;

  // 数量单位
  // 一般是 "1",表示件
  pieceUnitCode: string;

  // 暂不清楚作用
  // 一般是 null
  individuallyPacked: null | string;

  // 预览图
  // 一般是轮播图的第一张图片
  thumbUrl: string;

  // 变种属性
  // 通过 ProductSkuSpecReqs 序列化生成
  // ProductSkuSpecReqs 一般只有一个成员
  productSkuSpecReqs: string;

  // 仓库信息
  // 通过 ProductSkuStockQuantityReqs 序列化生成
  // ProductSkuStockQuantityReqs 一般只有一个成员
  productSkuStockQuantityReq: string;
}

export enum PackageShape {
  '不规则' = 0,
  '长方体' = 1,
  '圆柱体' = 2,
}

export enum PackageType {
  '硬包装' = 0,
  '软包装+硬物' = 1,
  '软包装+软物' = 2,
}

// 通过产品信息文档来解析产品的信息
export interface ProductInfo {
  // giga 的产品 itemCode 加 gigaProductId
  // 对应 giga 信息的 skuIdInfo
  skuIdInfo: string;

  // giga 的产品 itemCode
  // 对应 giga 信息的 gigaSku
  gigaSku: string;

  // giga 的产品 id
  // 对应 giga 信息的 gigaProductId
  gigaProductId: string;

  // 店小秘产品的 id
  id: string;

  // 店小秘产品的 productId,值会为 "0"
  productId: string;

  // 店小秘店铺账号的 id,是一个下拉框可以选择店铺的账号。
  // 这是一个配置项
  // 可以通过 https://www.dianxiaomi.com/api/userInfo.json 返回
  shopId: string;

  // 店小秘产品的在线状态
  // draft 表示在采集箱
  // 这是一个配置项
  dxmState: DxmState;

  // 店小秘分类类型。暂不清楚意义。值为 0
  categoryType: '' | number;

  // 产品分类 id。是一个下拉框可以选择产品分类
  //  24823,表示(其他 庭院套装)。这个需要配置
  // 可以从 https://www.dianxiaomi.com/popTemuCategory/getBrand.json 接口获取
  categoryId: '' | number;

  // 结合产品分类 id 使用
  // 如果是 24823,可以使用下面的
  // [{"valueUnit":"","propValue":"<5","propName":"任一sku装配零件数","refPid":7096,"vid":"202791","pid":2148,"templatePid":1377982,"numberInputValue":""},{"valueUnit":"","propValue":"混合色","propName":"颜色","refPid":63,"vid":"26419","pid":13,"templatePid":1244294,"numberInputValue":""},{"valueUnit":"","propValue":"其他材料","propName":"顶部材料","refPid":580,"vid":"29414","pid":121,"templatePid":205700,"numberInputValue":""},{"valueUnit":"","propValue":"其他材料","propName":"材料","refPid":121,"vid":"24838","pid":89,"templatePid":205690,"numberInputValue":""},{"valueUnit":"","propValue":"SENBOWE","propName":"品牌名","refPid":1960,"vid":"41500","pid":1467,"templatePid":1150630,"numberInputValue":"","controlType":1}]
  // 这个需要配置
  // POP_TEMU_PRODUCT_FN.saveFn.getSubmitData() 方法可以生成 attributes 属性
  attributes: string;

  // 店小秘分类 id。是一个下拉框可以选择店小秘分类
  // 一般是 4028693-,表示(未分类)
  // 可以通过 https://www.dianxiaomi.com/popTemuProduct/add.htm 获取
  fullCid: string;

  // 来源 URL,表示产品的来源
  // 对应 giga 信息的 productUrl
  sourceUrl: string;

  // 产品标题
  // 对应 giga 信息的 productName 经过 ai 修改后获取
  productName: string;

  // 英文标题
  // 对应 giga 信息的 productName 经过 ai 修改后获取
  // 格式为:"{\"en\":\"Queen Size Upholstered Tufted Bed Frame - Elegant Mid-Century Velvet Daybed with Comfortable Backrest an Armrests for Bedroom and Living Room - Brown (85.5'' x 64.5'' x 30.5''d)\"}"
  productNameI18n: string;

  // 产品货号
  // 通过 MainProductSkuSpecReqs 序列化生成
  // MainProductSkuSpecReqs 一般只有一个成员
  mainProductSkuSpecReqs: string;

  // 产地
  // 一般是中国,对应 CN
  // 这是一个配置项
  // 可以通过 https://www.dianxiaomi.com/static/commData/countryCodeData.js?v=1 获取
  productOrigin: string;

  // 产地省份的 id
  // 一般是广东省,对应 43000000000006
  // 在中国产地是 CN 时用
  // 这是一个配置项
  // 可以通过 https://www.dianxiaomi.com/static/commData/countryRegionCodeData.js?v=1 获取
  region2Id: string;

  originFileUrl: string;

  // 站外产品链接
  // 一般是 ""
  outerGoodsUrl: string;

  // 是否是敏感属性
  // 一般是 ''
  // 如果是非字符串,表示存在敏感属性设置
  sensitiveAttr: string;

  // 是否是定制产品
  // 一般是 "0" 表示不是定制产品
  personalizationSwitch: 0 | 1;

  // 轮播图设置,不同的图片地址使用 | 分隔
  // 对应 giga 中资源收集中的经过 ai 处理的轮播图图片
  mainImage: string;

  // 暂不清楚作用
  // 一般是 '0'
  dxmVideoId: '0';

  // 暂不清楚作用
  // 一般是 ''
  draftImgUrl: string;

  // 产品素材图
  // 对应 giga 中资源收集中的经过 ai 处理的轮播图图片中的第一张图
  materialImgUrl: string;

  // 暂不清楚作用
  // 一般是 "'[]'"
  optionValue: string;

  // 如果有视频那么表示视频的缩略图地址,如果没有视频可以忽略。
  // 一般是 ""
  videoThumbnail?: string;

  // 如果有视频那么表示视频的地址,如果没有视频可以忽略。
  // 对应 giga 中资源收集中的视频
  videoUrl?: string;

  // 变体信息
  // 一般通过 VariationListStr 序列化生成
  // VariationList 一般只有一个成员
  // VariationList 一般只有一个成员
  variationListStr: string;

  // 暂不清楚作用
  // 一般是 ''
  goodsModel: string;

  // 外包装形状
  // 一般是 ''
  packageShape: '' | PackageShape;

  // 外包装形状
  // 一般是 ''
  packageType: '' | number;

  // 外包装图片
  // 一般是 ''
  packageImages: string;

  // 产品描述
  // 一般通过 DescriptionType 序列化生成
  // 对应 giga 中的 feature,description 属性,还包括了 giga 资源通过 ai 处理的轮播图
  description: string;

  // 承诺发货时效
  // 一般是 '172800'
  // 表示 2 个工作日内发货
  shipmentLimitSecond: ShipmentLimitSecond;

  // 运费模版
  // 一般是 "HFT-11640433187717260900",表示包邮模版
  // https://www.dianxiaomi.com/popTemuCategory/syncTemuShipments.json
  freightTemplateId: string;

  // 暂不清楚作用
  // 一般是 '100'
  productSemiManagedReq: string;

  // 暂不清楚作用
  // 一般是 "[{\"warehouseId\":\"WH-09092282531990900\",\"siteIdList\":[\"100\"]}]"
  productWarehouseRouteReq: string;

  // 暂不清楚作用
  // 一般是 ''
  dxmPdfUrl: string;

  // 产品说明书的 id
  // 需要上传后并且关联对应的店铺后获取
  instructionsId?: string;

  // 和产品说明书相关
  // 一般是 ''
  instructionsTranslateId: string;

  // 产品说明书的语言
  instructionsLanguages?: string;

  // 产品说明书文件名
  // 一般是 ''
  instructionsName?: string;

  // 暂不清楚作用
  // 一般是 ''
  qualifiedEn: string;

  // 暂不清楚作用
  // 一般是 ''
  sizeTemplateIds: string;
}

export interface ExtraProductInfo {
  skuIdInfo: string;
  gigaSku: string;
  gigaProductId: string;
}

// function getvariationListStr(variationListStr: string) {
//   let list = JSON.parse(variationListStr) as Array<any>;
//   list = list.map((item) => {
//     return {
//       id: item.id,
//       productSkuId: item.productSkuId,
//       supplierPrice: item.supplierPrice,
//       extCode: item.extCode,
//       length: item.length,
//       width: item.width,
//       height: item.height,
//       weight: item.weight,
//       codeType: item.codeType,
//       code: item.code,
//       sitePriceInfo: item.sitePriceInfo,
//       suggestedPrice: item.suggestedPrice,
//       suggestedPriceCurrencyType: item.suggestedPriceCurrencyType,
//       numberOfPieces: item.numberOfPieces,
//       skuClassification: item.skuClassification,
//       pieceUnitCode: item.pieceUnitCode,
//       individuallyPacked: item.individuallyPacked,
//       thumbUrl: item.thumbUrl,
//       productSkuSpecReqs: item.productSkuSpecReqs,
//       productSkuStockQuantityReq: item.productSkuStockQuantityReq,
//     };
//   });
//   return JSON.stringify(list);
// }

// 用来解析数字值
export function parseNumber(value: string) {
  if (value === '') {
    return '';
  }
  const num = Number(value);
  if (isNaN(num)) {
    return '';
  }
  return num;
}
export function parseProductInfoDocument(
  productDocument: Document,
  extraProductInfo: ExtraProductInfo,
): ProductInfo {
  // console.log(productDocument);
  // console.log(productDocument.documentElement.innerHTML.indexOf('HFT-11640433187717260900'));
  // console.log(productDocument.documentElement.innerHTML.lastIndexOf('HFT-11640433187717260900'));
  const id = productDocument.querySelector<HTMLInputElement>('input#idStr')?.value || '';
  const productId = productDocument.querySelector<HTMLInputElement>('input#productId')?.value || '';
  const shopId =
    productDocument.querySelector<HTMLOptionElement>(
      '.popTemuProductAddForm select[name=shopId] option[selected]',
    )?.value || '';
  const dxmState = (productDocument.querySelector<HTMLInputElement>('input#dxmState')?.value ||
    '') as DxmState;
  const categoryType = parseNumber(
    productDocument.querySelector<HTMLInputElement>('input#categoryType')?.value || '',
  );
  const categoryId = parseNumber(
    productDocument.querySelector<HTMLInputElement>('input#categoryId')?.value || '',
  );
  const fullCid = productDocument.querySelector<HTMLButtonElement>('#fullCid')?.dataset.id || '';
  const sourceUrl =
    productDocument.querySelector<HTMLInputElement>('input[name=sourceUrl]')?.value || '';
  const attributes =
    productDocument.querySelector<HTMLInputElement>('input#attributesData')?.value || '';
  const productName =
    productDocument.querySelector<HTMLInputElement>('input#productTitle')?.value || '';
  const productNameI18n =
    productDocument.querySelector<HTMLInputElement>('input#productNameI18n')?.value || '';
  const productOrigin =
    productDocument.querySelector<HTMLInputElement>('input#productOrigin')?.value || '';
  const region2Id =
    productDocument.querySelector<HTMLInputElement>('input#productOrigin0')?.value || '';

  // 暂不清楚作用
  const originFileUrl = '';
  const outerGoodsUrl =
    productDocument.querySelector<HTMLInputElement>('input#outerGoodsUrl')?.value || '';
  const mainImage =
    productDocument.querySelector<HTMLInputElement>('input#mainImgList')?.value || '';

  // 暂不清楚作用
  const dxmVideoId = '0';

  const draftImgUrl =
    productDocument.querySelector<HTMLInputElement>('input#draftImgUrl')?.value || '';
  const sensitiveAttr =
    productDocument.querySelector<HTMLInputElement>('input#sensitiveAttrData')?.value || '';
  // 产品素材图只有用户选择了图片后才会显示,这里默认使用了轮播图的第一张图
  const materialImgUrl = mainImage ? mainImage.split('|')[0] : '';
  // optionValue 不清楚作用
  const optionValue = "'[]'";
  // const productNumber
  const mainProductSkuSpecReqs =
    productDocument.querySelector<HTMLInputElement>('input#productNumber')?.dataset.showval || '';

  // 变种信息只上传部分的信息
  let variationListStr =
    productDocument.querySelector<HTMLInputElement>('input#popTemuVariation')?.dataset
      .skutablelist || '';
  // 这里尝试上传所有的信息
  variationListStr = variationListStr;
  const description =
    productDocument.querySelector<HTMLInputElement>('input#proDescriptionData')?.value || '';
  const personalizationSwitch = (productDocument.querySelector<HTMLInputElement>(
    'input[name=personalizationSwitch][checked]',
  )?.value || 0) as 0 | 1;
  // goodsModel 不清楚作用
  const goodsModel = '';
  const packageShape = parseNumber(
    productDocument.querySelector<HTMLInputElement>('input#packageShapeValueIpt')?.value || '',
  );
  const packageType = parseNumber(
    productDocument.querySelector<HTMLInputElement>('input#packageTypeValueIpt')?.value || '',
  );
  const packageImages =
    productDocument.querySelector<HTMLInputElement>('input#packageImgList')?.value || '';
  const productSemiManagedReq =
    productDocument.querySelector<HTMLInputElement>('input#productSemiManagedReq')?.value || '';
  const shipmentLimitSecond = (productDocument.querySelector<HTMLInputElement>(
    'input.deliveryTime[checked]',
  )?.value || '') as ShipmentLimitSecond;
  const freightTemplateId =
    productDocument.querySelector<HTMLDivElement>('div#freightTemplateBox')?.dataset.show || '';
  const productWarehouseRouteReq =
    productDocument.querySelector<HTMLInputElement>('input#productWarehouseRouteReq')?.value || '';
  const dxmPdfUrl = productDocument.querySelector<HTMLInputElement>('input#dxmPdfUrl')?.value || '';
  const instructionsId =
    productDocument.querySelector<HTMLInputElement>('input#instructionsId')?.value || '';
  const qualifiedEn =
    productDocument.querySelector<HTMLInputElement>('input#qualifiedEn')?.value || '';
  const instructionsTranslateId =
    productDocument.querySelector<HTMLInputElement>('input#instructionsTranslateId')?.value || '';
  const instructionsName =
    productDocument.querySelector<HTMLInputElement>('input#instructionsName')?.value || '';
  const sizeTemplateIds =
    productDocument.querySelector<HTMLInputElement>('input#popTemuSizeTemplateId')?.value || '';
  return {
    ...extraProductInfo,
    id,
    productId,
    shopId,
    dxmState,
    categoryType,
    categoryId,
    fullCid,
    sourceUrl,
    attributes,
    productName,
    productNameI18n,
    productOrigin,
    region2Id,
    originFileUrl,
    outerGoodsUrl,
    mainImage,
    dxmVideoId,
    draftImgUrl,
    materialImgUrl,
    sensitiveAttr,
    optionValue,
    mainProductSkuSpecReqs,
    variationListStr,
    description,
    personalizationSwitch,
    goodsModel,
    packageShape,
    packageType,
    packageImages,
    productSemiManagedReq,
    shipmentLimitSecond,
    freightTemplateId,
    productWarehouseRouteReq,
    dxmPdfUrl,
    instructionsId,
    qualifiedEn,
    instructionsTranslateId,
    instructionsName,
    sizeTemplateIds,
  };
}

export interface DescriptionTextType {
  lanng: string;
  type: 'text';
  priority: number;
  contentList: Array<{
    text: string;
    textModuleDetails: {
      fontFamily: string | null;
      fontColor: string;
      backgroundColor: string;
      fontSize: string;
      align: 'left' | 'center' | 'right';
    };
  }>;
}
export interface DescriptionImageType {
  lanng: string;
  type: 'image';
  priority: number;
  contentList: Array<{
    imgUrl: string;
    height: number;
    width: number;
  }>;
}
export type DescriptionType = DescriptionImageType | DescriptionTextType;

// 处理详细信息中的产品特性内容
export function getFeatureDetail(feature: string[], hasHeader: boolean): DescriptionTextType {
  let text = '';
  if (hasHeader) {
    text += 'Product Features\n';
  }
  feature.forEach((content) => {
    text += content + '\n';
  });
  return {
    lanng: 'zh-CN',
    type: 'text',
    priority: 0,
    contentList: [
      {
        // 保证不大于 500 个字符
        text: text.slice(0, 490),
        textModuleDetails: {
          fontFamily: null,
          fontColor: '#333333',
          backgroundColor: '#ffffff',
          fontSize: '16px',
          align: 'left',
        },
      },
    ],
  };
}

// 处理详细信息中的产品 Description 内容
export function getCharacteristicDetail(
  description: {
    name: string;
    value: string;
  }[],
  hasHeader: boolean,
): DescriptionTextType {
  let text = '';
  if (hasHeader) {
    text += 'Description\n';
  }
  description.forEach(({ name, value }) => {
    text += `${name}:  ${value}` + '\n';
  });
  return {
    lanng: 'zh-CN',
    type: 'text',
    priority: 0,
    contentList: [
      {
        // 保证不大于 500 个字符
        text: text.slice(0, 490),
        textModuleDetails: {
          fontFamily: null,
          fontColor: '#333333',
          backgroundColor: '#ffffff',
          fontSize: '16px',
          align: 'left',
        },
      },
    ],
  };
}

// 处理图片信息
export function getImageDetail(imageUrl: string): DescriptionImageType {
  return {
    lanng: 'zh-CN',
    type: 'image',
    priority: 0,
    contentList: [
      {
        imgUrl: imageUrl,
        height: 0,
        width: 0,
      },
    ],
  };
}

// 序列化描述信息
export function serializeDescription(
  imageUrls: string[],
  feature: string[],
  description: {
    name: string;
    value: string;
  }[],
) {
  const descripts: DescriptionType[] = [];
  if (feature && feature.length > 0) {
    // 分块生成内容
    for (let i = 0; i < feature.length; i++) {
      if (i === 0) {
        descripts.push(getFeatureDetail([feature[i]], true));
      } else {
        descripts.push(getFeatureDetail([feature[i]], false));
      }
    }
  }
  if (description && description.length > 0) {
    // 分块生成内容
    for (let i = 0; i < description.length; i++) {
      if (i === 0) {
        descripts.push(getCharacteristicDetail([description[i]], true));
      } else {
        descripts.push(getCharacteristicDetail([description[i]], false));
      }
    }
  }
  imageUrls.forEach((imageUrl) => {
    descripts.push(getImageDetail(imageUrl));
  });
  return JSON.stringify(descripts);
}

// 序列化 MainProductSkuSpecReq
export function serializeMainProductSkuSpecReqs(productInfo: ProductInfo, imageUrls: string[]) {
  const skuInfo = productInfo.skuIdInfo;
  return JSON.stringify([
    {
      parentSpecId: 0,
      parentSpecName: '',
      specId: 0,
      specName: '',
      previewImgUrls: imageUrls[1] || '',
      extCode: skuInfo,
      productSkcId: '',
    },
  ]);
}

// 序列化 variationListStr
export function serializeVariationListStr(
  productInfo: ProductInfo,
  collectedGigaProductDetailInfo: GigaProductDetialInfo,
  imageUrls: string[],
  priceMultiplyingFactor: number,
  warehouseId: string,
) {
  const skuInfo = productInfo.skuIdInfo;
  const supplierPrice = collectedGigaProductDetailInfo.totalPrice * priceMultiplyingFactor;
  let mainColor = collectedGigaProductDetailInfo.mainColor;
  if (
    mainColor.toUpperCase() === 'LIGHT GREY' ||
    mainColor.toUpperCase() === 'DARK GREY' ||
    mainColor.toUpperCase() === 'LIGHT GRAY' ||
    mainColor.toUpperCase() === 'DARK GRAY'
  ) {
    mainColor = 'GREY';
  }
  let length = +collectedGigaProductDetailInfo.packageLength;
  let width = +collectedGigaProductDetailInfo.packageWidth;
  let height = +collectedGigaProductDetailInfo.packageHeight;
  const dims = [length, width, height].sort((a, b) => b - a);
  length = dims[0];
  width = dims[1];
  height = dims[2];

  return JSON.stringify([
    {
      id: null,
      productSkuId: 0,
      supplierPrice,
      extCode: collectedGigaProductDetailInfo.skuIdInfo,
      // 单位是 mm。英寸转换
      length: length * 25.4,
      width: width * 25.4,
      height: height * 25.4,
      // 单位是毫克,英镑转换
      weight: +collectedGigaProductDetailInfo.packageWeight * 453592.37,
      codeType: '1',
      code: '',
      sitePriceInfo: null,
      // 对应 giga 信息的 supplierPrice 加一美元
      suggestedPrice: supplierPrice + 100,
      suggestedPriceCurrencyType: 'USD',
      numberOfPieces: 1,
      skuClassification: 1,
      pieceUnitCode: '1',
      individuallyPacked: null,
      thumbUrl: imageUrls[0] || '',

      // 变种属性
      // 通过 ProductSkuSpecReqs 序列化生成
      // ProductSkuSpecReqs 一般只有一个成员
      // 如果 mainColor 是 LIGHT GREY 和 DARK GREY,那么统一转化为 GREY
      productSkuSpecReqs: JSON.stringify([
        {
          parentSpecId: '1001',
          parentSpecName: '颜色',
          specId: 0,
          specName: mainColor,
        },
      ]),

      // 仓库信息
      // 通过 ProductSkuStockQuantityReqs 序列化生成
      // ProductSkuStockQuantityReqs 一般只有一个成员
      productSkuStockQuantityReq: JSON.stringify([
        {
          // 可以通过 https://www.dianxiaomi.com/popTemuCategory/warehouseList.json 获取,但是一般固定
          warehouseId: warehouseId,
          warehouseName: '上海仓',
          targetStockAvailable: collectedGigaProductDetailInfo.available,
        },
      ]),
    },
  ]);
}

// 上传图片到店小秘的服务器
export async function uploadImage(
  file: File,
  productInfo: ProductInfo,
  isUploadToImageSpace: boolean,
) {
  const bucket = 'wxalbum';
  const sign = await getSign(file, bucket, 'ap-shanghai');
  if (sign.code === 0) {
    const fileId = sign.data.fileId;
    const url = sign.data.url;
    const wxalbumIdMatch = url.match(/wxalbum-(\d+).cos/);
    const wxalbumId = wxalbumIdMatch ? wxalbumIdMatch[1] || '' : '';
    const uploadURL = `https://wxalbum${wxalbumId}.dianxiaomi.com${fileId}`;
    await uploadFileToCos(uploadURL, sign.data.sign, file);

    // 上传到图片空间中
    if (isUploadToImageSpace) {
      await cosDxmCallBack(file, productInfo.fullCid, fileId, bucket);
    }
    // const imageUrl = `https://wxalbum-${wxalbumId}.image.myqcloud.com/${fileId}`;
    const imageUrl = `https://wxalbum-${wxalbumId}-file.dianxiaomi.com${fileId}`;
    return imageUrl;
  } else {
    throw new Error(
      `[${productInfo.skuIdInfo}]: 图片上传时获取签名信息失败 ${JSON.stringify(sign)}`,
    );
  }
}

// 上传视频到店小秘的服务器
export async function uploadVideo(
  file: File,
  productInfo: ProductInfo,
  isUploadToImageSpace: boolean,
) {
  const bucket = 'smtmedia';
  const sign = await getSign(file, bucket, 'ap-guangzhou');
  if (sign.code === 0) {
    const fileId = sign.data.fileId;
    const url = sign.data.url;
    const uploadURL = `https:${url}`;
    await uploadFileToCos(uploadURL, sign.data.sign, file);

    // 上传到图片空间中
    if (isUploadToImageSpace) {
      await cosDxmCallBack(file, productInfo.fullCid, fileId, bucket);
    }
    return uploadURL;
  } else {
    throw new Error(
      `[${productInfo.skuIdInfo}]: 视频上传时获取签名信息失败 ${JSON.stringify(sign)}`,
    );
  }
}

// 上传产品说明到店小秘的服务器
export async function uploadInstructions(file: File, productInfo: ProductInfo) {
  const bucket = 'emailtmp';
  const sign = await getSign(file, bucket, 'ap-guangzhou');
  if (sign.code === 0) {
    const fileId = sign.data.fileId;
    const url = sign.data.url;
    const uploadURL = `https:${url}`;
    await uploadFileToCos(uploadURL, sign.data.sign, file);
    return uploadURL;
  } else {
    throw new Error(
      `[${productInfo.skuIdInfo}]: 产品说明书上传时获取签名信息失败 ${JSON.stringify(sign)}`,
    );
  }
}

// 读取目录下的图像文件对象
export async function getImagesFile(imagesDirectoryHandle: FileSystemDirectoryHandle) {
  // 读取目录下的所有图像文件
  const imageFileSystemFileHandles: FileSystemFileHandle[] =
    await getAllFileHandleByDirectoryHandle(imagesDirectoryHandle);
  // 按名称进行排序
  imageFileSystemFileHandles.sort((a, b) => {
    const aFileName = getFileName(a.name);
    const bFileName = getFileName(b.name);
    const aFileNameNum = parseFloat(aFileName);
    const bFileNameNum = parseFloat(bFileName);
    if (!isNaN(aFileNameNum) && !isNaN(bFileNameNum)) {
      return aFileNameNum - bFileNameNum;
    } else {
      return aFileName.localeCompare(bFileName);
    }
  });
  const imageFiles = await Promise.all(
    imageFileSystemFileHandles.map((fileHandle) => {
      return fileHandle.getFile();
    }),
  );
  return imageFiles;
}

// 读取货号目录下的视频文件对象
export async function getVideoFile(
  skuIdInfoDirectoryHandle: FileSystemDirectoryHandle,
  productVideoDirectorname: string,
): Promise<File | null> {
  try {
    const videoFileSystemDirectoryhandle = await skuIdInfoDirectoryHandle.getDirectoryHandle(
      productVideoDirectorname,
      {
        create: false,
      },
    );
    // 如果存在就获取到一个视频文件对象
    const videoFileSystemFiles = await getAllFileHandleByDirectoryHandle(
      videoFileSystemDirectoryhandle,
    );
    // 视频文件中可能会有文本文件需要过滤出来
    const files = await Promise.all(
      videoFileSystemFiles.map((fileHandle) => {
        return fileHandle.getFile();
      }),
    );
    const videoFiles = files.filter((file) => {
      return file.type.toLowerCase() === 'video/mp4';
    });
    if (videoFiles.length > 0) {
      return videoFiles[0];
    } else {
      return null;
    }
  } catch (error) {
    console.log(error);
    return null;
  }
}

// 读取货号目录下的产品说明书文件对象
export async function getInstructionsFile(
  skuIdInfoDirectoryHandle: FileSystemDirectoryHandle,
  instructionsDirectorname: string,
): Promise<File | null> {
  try {
    const instructionsFileSystemDirectoryhandle = await skuIdInfoDirectoryHandle.getDirectoryHandle(
      instructionsDirectorname,
      {
        create: false,
      },
    );
    // 获取文件大小最大的文件对象
    const instructionsFileSystemFiles = await getAllFileHandleByDirectoryHandle(
      instructionsFileSystemDirectoryhandle,
    );
    const files = await Promise.all(
      instructionsFileSystemFiles.map((fileHandle) => {
        return fileHandle.getFile();
      }),
    );
    const instructionsFileSystemFile = files.reduce((prev, current) => {
      return prev.size > current.size ? prev : current;
    });
    if (instructionsFileSystemFile) {
      return instructionsFileSystemFile;
    } else {
      return null;
    }
  } catch (error) {
    console.log(error);
    return null;
  }
}

// 获取店小秘的所有产品信息
export async function getAllProductInfos(
  batchGetProductInfoOptions: BatchGetProductInfoOptions = {},
) {
  let allProducts: DianxiaomiProductInfo[] = [];
  let hasMore = true;
  let pageNo = batchGetProductInfoOptions.pageNo ?? 1;
  const pageSize = batchGetProductInfoOptions.pageSize ?? 300;

  while (hasMore) {
    const result = await batchGetProductInfo<BatchGetProductInfoResult>({
      ...batchGetProductInfoOptions,
    });

    // 假设 result.data.list 是产品数组，result.data.total 是总数
    const products = result?.data?.page?.list ?? [];
    allProducts = allProducts.concat(products);

    // 判断是否还有下一页
    const total = result?.data?.page?.totalSize ?? 0;
    if (allProducts.length >= total || products.length < pageSize) {
      hasMore = false;
    } else {
      pageNo += 1;
    }
  }

  return allProducts;
}
